package database

import (
	"database/sql"
	"fmt"
	"time"

	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
	
	// 使用纯 Go SQLite 驱动
	_ "modernc.org/sqlite"
)

// Task 数据库任务结构
type Task struct {
	ID          string    `json:"id" gorm:"primaryKey"`
	Name        string    `json:"name"`
	Command     string    `json:"command"`
	Schedule    string    `json:"schedule"`
	Enabled     bool      `json:"enabled"`
	Running     bool      `json:"running" gorm:"default:false"`
	IsPinned    bool      `json:"isPinned" gorm:"default:false"`
	LastRun     time.Time `json:"lastRun"`
	NextRun     time.Time `json:"nextRun"`
	CreatedAt   time.Time `json:"createdAt"`
	UpdatedAt   time.Time `json:"updatedAt"`
	Description string    `json:"description"`
}

// TaskLog 任务日志结构
type TaskLog struct {
	ID        uint      `json:"id" gorm:"primaryKey"`
	TaskID    string    `json:"taskId"`
	TaskName  string    `json:"taskName"`
	Status    string    `json:"status"`
	Output    string    `json:"output" gorm:"type:text"`
	StartTime time.Time `json:"startTime"`
	EndTime   *time.Time `json:"endTime,omitempty"`
	Duration  int64     `json:"duration"`
	ExitCode  int       `json:"exitCode"`
	Error     string    `json:"error"`
	CreatedAt time.Time `json:"createdAt"`
}

// Settings 系统设置结构
type Settings struct {
	ID                        uint      `json:"id" gorm:"primaryKey"`
	SystemName                string    `json:"systemName" gorm:"default:'Skedule'"`
	MaxConcurrentTasks        int       `json:"maxConcurrentTasks" gorm:"default:10"`
	LogRetentionDays          int       `json:"logRetentionDays" gorm:"default:30"`
	EnableFailureNotification bool      `json:"enableFailureNotification" gorm:"default:false"`
	EmailAddress              string    `json:"emailAddress"`
	UpdatedAt                 time.Time `json:"updatedAt"`
	CreatedAt                 time.Time `json:"createdAt"`
}

// DB 全局数据库实例
var DB *gorm.DB

// InitDB 初始化数据库
func InitDB(dbPath string) error {
	var err error
	
	// 使用纯 Go SQLite 驱动创建数据库连接
	sqlDB, err := sql.Open("sqlite", dbPath)
	if err != nil {
		return fmt.Errorf("failed to open database: %v", err)
	}
	
	// 使用现有的 SQL 连接创建 GORM 实例
	DB, err = gorm.Open(sqlite.Dialector{Conn: sqlDB}, &gorm.Config{
		Logger: logger.Default.LogMode(logger.Silent), // 设置为静默模式，减少日志输出
	})
	
	if err != nil {
		sqlDB.Close()
		return fmt.Errorf("failed to create GORM instance: %v", err)
	}

	// 自动迁移数据库表结构
	err = DB.AutoMigrate(&Task{}, &TaskLog{}, &Settings{})
	if err != nil {
		return err
	}

	// 初始化默认设置
	if err := initDefaultSettings(); err != nil {
		return err
	}

	return nil
}

// initDefaultSettings 初始化默认系统设置
func initDefaultSettings() error {
	var count int64
	DB.Model(&Settings{}).Count(&count)
	
	// 如果没有设置记录，创建默认设置
	if count == 0 {
		defaultSettings := Settings{
			SystemName:                "Skedule",
			MaxConcurrentTasks:        10,
			LogRetentionDays:          30,
			EnableFailureNotification: false,
			EmailAddress:              "",
			CreatedAt:                 time.Now(),
			UpdatedAt:                 time.Now(),
		}
		
		return DB.Create(&defaultSettings).Error
	}
	
	return nil
}

// CloseDB 关闭数据库连接
func CloseDB() error {
	if DB != nil {
		sqlDB, err := DB.DB()
		if err != nil {
			return err
		}
		return sqlDB.Close()
	}
	return nil
}

// GetTaskByID 根据ID获取任务
func GetTaskByID(id string) (*Task, error) {
	var task Task
	err := DB.Where("id = ?", id).First(&task).Error
	return &task, err
}

// UpdateTaskRunningStatus 更新任务运行状态
func UpdateTaskRunningStatus(taskID string, running bool) error {
	return DB.Model(&Task{}).Where("id = ?", taskID).Update("running", running).Error
}

// UpdateTaskLastRun 更新任务最后执行时间
func UpdateTaskLastRun(taskID string, lastRun time.Time) error {
	return DB.Model(&Task{}).Where("id = ?", taskID).Updates(map[string]interface{}{
		"last_run":   lastRun,
		"updated_at": time.Now(),
	}).Error
}

// CreateTaskLog 创建任务日志
func CreateTaskLog(log *TaskLog) error {
	return DB.Create(log).Error
}

// GetRecentLogs 获取最近的日志记录
func GetRecentLogs(limit int) ([]TaskLog, error) {
	var logs []TaskLog
	err := DB.Order("created_at DESC").Limit(limit).Find(&logs).Error
	return logs, err
} 